package com.sina.microblog
{
	import com.adobe.crypto.HMAC;
	import com.adobe.crypto.SHA1;
	import com.dynamicflash.util.Base64;
	import com.sina.microblog.data.MicroBlogComment;
	import com.sina.microblog.data.MicroBlogCount;
	import com.sina.microblog.data.MicroBlogDirectMessage;
	import com.sina.microblog.data.MicroBlogProfileUpdateParams;
	import com.sina.microblog.data.MicroBlogRateLimit;
	import com.sina.microblog.data.MicroBlogStatus;
	import com.sina.microblog.data.MicroBlogUser;
	import com.sina.microblog.data.MicroBlogUsersRelationship;
	import com.sina.microblog.events.MicroBlogErrorEvent;
	import com.sina.microblog.events.MicroBlogEvent;
	import com.sina.microblog.utils.GUID;
	import com.sina.microblog.utils.StringEncoders;
	import com.ut.nm_test_internal;
	
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.IOErrorEvent;
	import flash.events.SecurityErrorEvent;
	import flash.net.URLLoader;
	import flash.net.URLRequest;
	import flash.net.URLRequestHeader;
	import flash.net.URLRequestMethod;
	import flash.net.URLVariables;
	import flash.net.getClassByAlias;
	import flash.net.navigateToURL;
	import flash.system.ApplicationDomain;
	import flash.system.Capabilities;
	import flash.utils.ByteArray;
	import flash.utils.Dictionary;
	import flash.utils.Endian;
	import flash.utils.getDefinitionByName;

	use namespace nm_test_internal;
	
	/**
	 *  当OAuth过程发生错误时触发该事件.
	 *
	 *  <p>当consumerKey和consumerSecret不为空时，使用OAuth方式进行认证</p>
	 *
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="oauthCertifcateError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载公共微博消息成功时触发该事件.
	 *
	 *  <p>调用loadPublicTimeLine成功时，事件的<code>result</code>属性为一个<code>MicroBlogStatus</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadPublicTimeLineResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载公共微博消息失败时触发该事件.
	 *
	 *  <p>调用loadPublicTimeLine失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadPublicTimeLineError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载用户所有关注的用户最新的n条微博消息成功时触发该事件.
	 *
	 *  <p>调用loadFriendsTimeLine成功时，事件的<code>result</code>属性为一个<code>MicroBlogStatus</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadFriendsTimeLineResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载用户所有关注的用户最新的n条微博消息失败时触发该事件.
	 *
	 *  <p>调用loadFriendsTimeLine失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadFriendsTimeLineError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载指定用户的微博消息成功时触发该事件.
	 *
	 *  <p>调用loadUserTimeLine成功时，事件的<code>result</code>属性为一个<code>MicroBlogStatus</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadUserTimeLineResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载指定用户的微博消息失败时触发该事件.
	 *
	 *  <p>调用loadUserTimeLine失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadUserTimeLineError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载提及博主的微博消息成功时触发该事件.
	 *
	 *  <p>调用loadMensions成功时，事件的<code>result</code>属性为一个<code>MicroBlogStatus</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadMensionsResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载指定用户的微博消息失败时触发该事件.
	 *
	 *  <p>调用loadMensions失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadMensionsError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载对博主所发微博消息的评论成功时触发该事件.
	 *
	 *  <p>调用loadCommentsTimeline成功时，事件的<code>result</code>属性为一个<code>MicroBlogComment</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadCommentsTimelineResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载指定用户的微博消息失败时触发该事件.
	 *
	 *  <p>调用loadMensions失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadCommentsTimelineError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载博主所发表评论成功时触发该事件.
	 *
	 *  <p>调用loadMyComments成功时，事件的<code>result</code>属性为一个<code>MicroBlogComment</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadMyCommentsResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载博主所发表评论失败时触发该事件.
	 *
	 *  <p>调用loadMyComments失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadMyCommentsError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载对微博消息的评论成功时触发该事件.
	 *
	 *  <p>调用loadComments成功时，事件的<code>result</code>属性为一个<code>MicroBlogComment</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadCommentsResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载对微博消息的评论失败时触发该事件.
	 *
	 *  <p>调用loadComments失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadCommentsError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载微博消息相关统计数据成功时触发该事件.
	 *
	 *  <p>调用loadStatusCounts成功时，事件的<code>result</code>属性为一个<code>MicroBlogCount</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadStatusCountsResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载微博消息相关统计数据失败时触发该事件.
	 *
	 *  <p>调用loadStatusCounts失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadStatusCountsError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当发布微博消息成功时触发该事件.
	 *
	 *  <p>调用updateStatus成功时，事件的<code>result</code>属性为刚发布的<code>MicroBlogStatus</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="updateStatusResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当发布微博消息失败时触发该事件.
	 *
	 *  <p>调用updateStatus失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="updateStatusError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当删除微博消息成功时触发该事件.
	 *
	 *  <p>调用deleteStatus成功时，事件的<code>result</code>属性为被删除的<code>MicroBlogStatus</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="deleteStatusResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当删除微博消息失败时触发该事件.
	 *
	 *  <p>调用deleteStatus失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="deleteStatusError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载某个微博消息成功时触发该事件.
	 *
	 *  <p>调用loadStatusInfo成功时，事件的<code>result</code>属性为<code>MicroBlogStatus</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadStatusInfoResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载某个微博消息失败时触发该事件.
	 *
	 *  <p>调用loadStatusInfo失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadStatusInfoError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当删除某个微博消息评论成功时触发该事件.
	 *
	 *  <p>调用deleteComment成功时，事件的<code>result</code>属性为<code>MicroBlogComment</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="deleteCommentResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当删除某个微博消息评论失败时触发该事件.
	 *
	 *  <p>调用deleteComment失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="deleteCommentError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当评论某个微博消息成功时触发该事件.
	 *
	 *  <p>调用commentStatus成功时，事件的<code>result</code>属性为<code>MicroBlogComment</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="commentStatusResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当评论某个微博消息失败时触发该事件.
	 *
	 *  <p>调用commentStatus失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="commentStatusError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当转发某个微博消息成功时触发该事件.
	 *
	 *  <p>调用repostStatus成功时，事件的<code>result</code>属性为<code>MicroBlogStatus</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="repostStatusResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当转发某个微博消息失败时触发该事件.
	 *
	 *  <p>调用repostStatus失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="repostStatusError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当回复某个微博评论成功时触发该事件.
	 *
	 *  <p>调用replyStatus成功时，事件的<code>result</code>属性为<code>MicroBlogStatus</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="replyStatusResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当回复某个微博评论失败时触发该事件.
	 *
	 *  <p>调用replyStatus失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="replyStatusError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载接收到的私信列表成功时触发该事件.
	 *
	 *  <p>调用loadDirectMessagesReceived成功时，事件的<code>result</code>属性为<code>MicroBlogDirectMessage</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadDirectMessagesReceivedResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载接收到的私信列表失败时触发该事件.
	 *
	 *  <p>调用loadDirectMessagesReceived失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadDirectMessagesReceivedError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载发出的私信列表成功时触发该事件.
	 *
	 *  <p>调用loadDirectMessagesSent成功时，事件的<code>result</code>属性为<code>MicroBlogDirectMessage</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadDicrectMessagesSentResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载发出的私信列表失败时触发该事件.
	 *
	 *  <p>调用loadDirectMessagesSent失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadDicrectMessagesSentError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当删除私信成功时触发该事件.
	 *
	 *  <p>调用deleteDirectMessage成功时，事件的<code>result</code>属性为被删除的<code>MicroBlogDirectMessage</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="deleteDirectMessageResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当删除私信失败时触发该事件.
	 *
	 *  <p>调用deleteDirectMessage失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="deleteDirectMessageError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当发送私信成功时触发该事件.
	 *
	 *  <p>调用sendDirectMessage成功时，事件的<code>result</code>属性<code>MicroBlogDirectMessage</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="sendDirectMessageResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当发送私信失败时触发该事件.
	 *
	 *  <p>调用deleteDirectMessage失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="sendDirectMessageSentError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载指定用户信息成功时触发该事件.
	 *
	 *  <p>调用loadUserInfo成功时，事件的<code>result</code>属性<code>MicroBlogUser</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadUserInfoResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载指定用户信息失败时触发该事件.
	 *
	 *  <p>调用loadUserInfo失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadUserInfoError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载用户关注的博主列表成功时触发该事件.
	 *
	 *  <p>调用loadFriendsInfo成功时，事件的<code>result</code>属性<code>MicroBlogUser</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadFriendsInfoResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载用户关注的博主列表失败时触发该事件.
	 *
	 *  <p>调用loadFriendsInfo失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadFriendsInfoError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载关注用户的博主列表成功时触发该事件.
	 *
	 *  <p>调用loadFollowersInfo成功时，事件的<code>result</code>属性<code>MicroBlogUser</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadFollowersInfoResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载关注用户的博主列表失败时触发该事件.
	 *
	 *  <p>调用loadFollowersInfo失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadFollowersInfoError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当关注某博主成功时触发该事件.
	 *
	 *  <p>调用follow成功时，事件的<code>result</code>属性<code>MicroBlogUser</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="followResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当关注某博主失败时触发该事件.
	 *
	 *  <p>调用follow失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="followError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当取消关注某博主成功时触发该事件.
	 *
	 *  <p>调用cancelFollowing成功时，事件的<code>result</code>属性<code>MicroBlogUser</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="cancelFollowingResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当取消关注某博主失败时触发该事件.
	 *
	 *  <p>调用cancelFollowing失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="cancelFollowingError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当查询两个微博用户关系成功返回时触发该事件.
	 *
	 *  <p>调用checkIsFollowing成功时，事件的<code>result</code>属性<code>MicroBlogRelationship</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="checkIsFollowingResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当查询两个微博用户关系失败时触发该事件.
	 *
	 *  <p>调用checkIsFollowing失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="checkIsFollowingError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加载博主关注的用户id列表成功时触发该事件.
	 *
	 *  <p>调用loadFriendsIDList成功时，事件的<code>result</code>属性<code>uint</code>
	 *  数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadFriendsIDListResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载博主关注的用户id列表失败时触发该事件.
	 *
	 *  <p>调用loadFriendsIDList失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadFriendsIDListError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当加关注载博主的用户id列表成功时触发该事件.
	 *
	 *  <p>调用loadFollowersIDList成功时，事件的<code>result</code>属性<code>uint</code>
	 *  数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadFollowersIDListResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载关注博主的用户id列表失败时触发该事件.
	 *
	 *  <p>调用loadFollowersIDList失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadFollowersIDListError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当验证用户信息成功和登陆成功时触发该事件.
	 *
	 *  <p>调用verifyCrendentials成功时，事件的<code>result</code>属性<code>MicroBlogUser</code>
	 *  对象.</p>
	 *  <p>注意：当使用Basic方式验证的时候调用login成功时也会触发该事件</p>
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="verifyCredentialsResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当验证用户信息失败时触发该事件.
	 *
	 *  <p>调用verifyCrendentials失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="verifyCredentialsError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当获取调用速率限制信息成功时触发该事件.
	 *
	 *  <p>调用getRateLimitStatus成功时，事件的<code>result</code>属性<code>MicroBlogUser</code>
	 *  数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="getRateLimitStatusResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当获取调用速率限制信息失败时触发该事件.
	 *
	 *  <p>调用getRateLimitStatus失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="getRateLimitStatusError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当用户成功注销时触发该事件.
	 *
	 *  <p>调用logout成功时，事件的<code>result</code>属性<code>MicroBlogRateLimit</code>
	 *  数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="logoutResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当用户注销失败时触发该事件.
	 *
	 *  <p>调用logout失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="logoutError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当更新用户信息成功时触发该事件.
	 *
	 *  <p>调用updateProfile成功时，事件的<code>result</code>属性<code>MicroBlogUser</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="updateProfileResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当更新用户信息失败时触发该事件.
	 *
	 *  <p>调用updateProfile失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="updateProfileError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当更新用户头像成功时触发该事件.
	 *
	 *  <p>调用updateProfileImage成功时，事件的<code>result</code>属性<code>MicroBlogUser</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="updateProfileImageResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当更新用户头像失败时触发该事件.
	 *
	 *  <p>调用updateProfileImage失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="updateProfileImageError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	
	/**
	 *  当加载用户收藏列表成功时触发该事件.
	 *
	 *  <p>调用loadFavoriteList成功时，事件的<code>result</code>属性<code>MicroBlogStatus</code>
	 *  对象数组.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadFavoriteListResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当加载用户收藏列表失败时触发该事件.
	 *
	 *  <p>调用loadFavoriteList失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadFavoriteListError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当收藏微博消息成功时触发该事件.
	 *
	 *  <p>调用addToFavorites成功时，事件的<code>result</code>属性<code>MicroBlogStatus</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="addToFavoritesResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当收藏微博消息失败时触发该事件.
	 *
	 *  <p>调用addToFavorites失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="addToFavoritesError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当将微博消息移出收藏列表成功时触发该事件.
	 *
	 *  <p>调用removeFromFavorites成功时，事件的<code>result</code>属性<code>MicroBlogStatus</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="removeFromFavoritesResult", type="com.sina.microblog.events.MicroBlogEvent")]	
	/**
	 *  当将微博消息移出收藏列表失败时触发该事件.
	 *
	 *  <p>调用addToFavorites失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="removeFromFavoritesError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当允许/不允许某用户通知成功时触发该事件.
	 *
	 *  <p>调用enableNotification成功时，事件的<code>result</code>属性<code>MicroBlogUser</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="enableNotificationResult", type="com.sina.microblog.events.MicroBlogEvent")]
	/**
	 *  当允许/不允许某用户通知失败时触发该事件.
	 *
	 *  <p>调用enableNotification失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="enableNotificationError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当请求省份，城市与id对应列表成功时触发该事件.
	 *
	 *  <p>调用loadProvinceCityIDList成功时，事件的<code>result</code>属性<code>XML</code>
	 *  对象.</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadProvinceCityIdListResult", type="flash.events.MicroBlogEvent")]
	/**
	 *  当请求省份，城市与id对应列表失败时触发该事件.
	 *
	 *  <p>调用loadProvinceCityIDList失败时，事件的<code>message</code>为失败原因描述</p>
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="loadProvinceCityIdListError", type="com.sina.microblog.events.MicroBlogErrorEvent")]
	
	/**
	 *  当请求未被验证，服务器调用产生安全错误时触发该事件.
	 *
	 *  @see flash.events.SecurityErrorEvent
	 *  
	 *  @langversion 3.0
	 *  @productversion MicroBlog-API 
	 */
	[Event(name="securityError", type="flash.events.SecurityErrorEvent")]
	
	/**
	 * MicroBlog是新浪微博AS3 API的核心类.
	 *
	 * <p>其主要功能包括：</br>
	 * <ul>
	 * <li>封装核心的平台API</li>
	 * <li>封装了两种用户认证方式：用户名/密码和OAuth方式</li>
	 * <li>使用事件来返回API调用结果</li>
	 * <li>对API调用的结果(XML)进行强类型的封装</li>
	 * </ul>
	 * 一般情况下，当一个API调用成功时，将会抛出一个<b>MicroBlogEvent</b>事件，而调用失败将会抛出<b>MicroBlogErrorEvent</b>事件。</br>
	 * 具体事件类型请参照函数说明文档。
	 * </p>
	 * <p>
	 * <b>例1 使用用户名密码进行用户认证</b>
	 * <pre><br/>
	 * private var mb:MicroBlog = new MicroBlog();
	 * public function init():void 
	 * {
	 * 		mb.login(username, password);
	 * }</pre>
	 * </p>
	 * <p>
	 * <b>例2 使用OAuth进行认证</b>
	 * <pre><br/>
	 * private var mb:MicroBlog = new MicroBlog();
	 * public function init():void
	 * {
	 * 		mb.consumerKey = xxxxxx;
	 * 		mb.consumerSecret = xxxxxx;
	 * 		if ( accessTokenKey &#38;&#38; accessTokenSecret )
	 * 		//如果保存了用户认证过的Token，则不需要登陆，也不需要pin_onClick的调用过程
	 * 		{
	 * 			mb.accessTokenKey = accessTokenKey;
	 * 			mb.accessTokenSecret = accessTokenSecret;
	 * 		} else
	 * 		{
	 * 			mb.login();
	 * 		}
	 * }
	 * //当用户在网页上认证了该请求以后
	 * private function pin_onClick():void
	 * {
	 * 		mb.pin = xxxxx;//如果不使用pin码，将pin置为空即可mb.pin="";
	 * }
	 * //然后就可以访问微博数据了
	 * </pre>
	 * </p>
	 * <p>
	 * <b>例3 一个典型的服务器调用过程，包括调用api，监听事件</b>
	 * <pre><br/>
	 * private var mb:MicroBlog = new MicroBlog();
	 * private function initListeners():void
	 * {
	 * 		mb.addEventListener(MicroBlogEvent.LOAD_PUBLIC_TIMELINE_RESULT, mb_onPublicTimeline, false, 0, true);
	 * 		mb.addEventListener(MicroBlogErrorEvent.LOAD_PUBLIC_TIMELINE_ERROR, mb_onError, false, 0, true);
	 * }
	 * public function loadPublicTimeline():void
	 * {
	 * 		mb.loadPublicTimeline();
	 * }
	 * private function mb_onPublicTimeline(event:MicroBlogEvent):void
	 * {
	 * 		//处理成功返回的数据
	 * 		var data:Array = event.result;
	 * 		xxxxxx
	 * }
	 * private function mb_onError(event:MicroBlogErrorEvent):void
	 * {
	 * 		var msg:String = event.message;
	 * 		xxxxxxx
	 * }
	 * </pre>
	 * </p>
	 *
	 */
	public class MicroBlog extends EventDispatcher
	{

		private static const API_BASE_URL:String="http://api.t.sina.com.cn/";

		private static const OAUTH_REQUEST_TOKEN_REQUEST_URL:String=API_BASE_URL + "oauth/request_token";
		//private static const OAUTH_REQUEST_TOKEN_REQUEST_URL:String="http://twitter.com/oauth/request_token";
		private static const OAUTH_AUTHORIZE_REQUEST_URL:String=API_BASE_URL + "oauth/authorize";
		private static const OAUTH_ACCESS_TOKEN_REQUEST_URL:String=API_BASE_URL + "oauth/access_token";

		private static const PUBLIC_TIMELINE_REQUEST_URL:String=API_BASE_URL + "statuses/public_timeline.xml";
		private static const FRIENDS_TIMELINE_REQUEST_URL:String=API_BASE_URL + "statuses/friends_timeline.xml";
		private static const USER_TIMELINE_REQUEST_URL:String=API_BASE_URL + "statuses/user_timeline$user.xml";
		private static const MENTIONS_REQUEST_URL:String=API_BASE_URL + "statuses/mentions.xml";
		private static const COMMENTS_TIMELINE_REQUEST_URL:String=API_BASE_URL + "statuses/comments_timeline.xml";
		private static const COMMENTS_BY_ME_REQUEST_URL:String=API_BASE_URL + "statuses/comments_by_me.xml";
		private static const COMMENTS_REQUEST_URL:String=API_BASE_URL + "statuses/comments.xml";
		private static const STATUS_COUNTS_REQUEST_URL:String=API_BASE_URL + "statuses/counts.xml";

		private static const UPDATE_STATUS_REQUEST_URL:String=API_BASE_URL + "statuses/update.xml";
		private static const UPDATE_STATUS_WITH_IMAGE_REQUEST_URL:String=API_BASE_URL + "statuses/upload.xml";
		private static const SHOW_STATUS_REQUEST_URL:String=API_BASE_URL + "statuses/show/$id.xml";
		private static const DELETE_STATUS_REQUEST_URL:String=API_BASE_URL + "statuses/destroy/$id.xml";
		private static const COMMENT_STATUS_REQUEST_URL:String=API_BASE_URL + "statuses/comment.xml";
		private static const DELETE_COMMENT_REQUEST_URL:String=API_BASE_URL + "statuses/comment_destroy/$id.xml";
		private static const REPOST_STATUS_REQUEST_URL:String=API_BASE_URL + "statuses/repost.xml";
		private static const REPLY_STATUS_REQUEST_URL:String=API_BASE_URL + "statuses/reply.xml";

		private static const LOAD_DIRECT_MESSAGES_RECEIVED_REQUEST_URL:String=API_BASE_URL + "direct_messages.xml";
		private static const LOAD_DIRECT_MESSAGES_SENT_REQUEST_URL:String=API_BASE_URL + "direct_messages/sent.xml";
		private static const SEND_DIRECT_MESSAGE_REQUEST_URL:String=API_BASE_URL + "direct_messages/new.xml";
		private static const DELETE_DIRECT_MESSAGE_REQUEST_URL:String=API_BASE_URL + "direct_messages/destroy/$id.xml";

		private static const LOAD_USER_INFO_REQUEST_URL:String=API_BASE_URL + "users/show$user.xml";
		private static const LOAD_FRIENDS_INFO_REQUEST_URL:String=API_BASE_URL + "statuses/friends$user.xml";
		private static const LOAD_FOLLOWERS_INFO_REQUEST_URL:String=API_BASE_URL + "statuses/followers$user.xml";

		private static const FOLLOW_REQUEST_URL:String=API_BASE_URL + "friendships/create$user.xml";
		private static const CANCEL_FOLLOWING_REQUEST_URL:String=API_BASE_URL + "friendships/destroy$user.xml";
		private static const CHECK_IS_FOLLOWING_REQUEST_URL:String=API_BASE_URL + "friendships/show.xml";

		private static const LOAD_FRIENDS_ID_LIST_REQUEST_URL:String=API_BASE_URL + "friends/ids$user.xml";
		private static const LOAD_FOLLOWERS_ID_LIST_REQUEST_URL:String=API_BASE_URL + "followers/ids$user.xml";
		
		private static const VERIFY_CREDENTIALS_REQUEST_URL:String=API_BASE_URL + "account/verify_credentials.xml";
		private static const GET_RATE_LIMIT_STATUS_REQUEST_URL:String=API_BASE_URL + "account/rate_limit_status.xml";
		private static const LOGOUT_REQUEST_URL:String=API_BASE_URL + "account/end_session.xml";
		private static const UPDATE_PROFILE_IMAGE_REQUEST_URL:String=API_BASE_URL + "account/update_profile_image.xml";
		private static const UPDATE_PROFILE_REQUEST_URL:String=API_BASE_URL + "account/update_profile.xml";

		private static const LOAD_FAVORITE_LIST_REQUEST_URL:String=API_BASE_URL + "favorites.xml";
		private static const ADD_TO_FAVORITES_REQUEST_URL:String=API_BASE_URL + "favorites/create.xml";
		private static const REMOVE_FROM_FAVORITES_REQUEST_URL:String=API_BASE_URL + "favorites/destroy/$id.xml";

		private static const ENABLE_NOTIFICATION_REQUEST_URL:String=API_BASE_URL + "notifications/$enabled$user.xml";
	
		private static const LOAD_PROVINCE_CITY_ID_LIST:String=API_BASE_URL + "provinces.xml";
//		private static const VERIFY_CREDENTIALS:String = "1";
//		private static const LOGOUT:String = "2";

		private static const USER_ID:String="user_id";
		private static const SCREEN_NAME:String="screen_name";
		private static const SINCE_ID:String="since_id";
		private static const MAX_ID:String="max_id";
		private static const COUNT:String="count";
		private static const PAGE:String="page";
		private static const ROLE:String="role";
		private static const ID:String="id";
		private static const CURSOR:String="cursor";
		private static const FOLLOW:String="follow";
		private static const SOURCE_ID:String="source_id";
		private static const SOURCE_SCREEN_NAME:String="source_screen_name";
		private static const TARGET_ID:String="target_id";
		private static const TARGET_SCREEN_NAME:String="target_screen_name";

		private static const MULTIPART_FORMDATA:String="multipart/form-data; boundary=";
		private static const CONTENT_DISPOSITION_BASIC:String='Content-Disposition: form-data; name="$name"';

		private static const CONTENT_TYPE_JPEG:String="Content-Type: image/pjpeg";
		private static const CONTENT_TRANSFER_ENCODING:String="Content-Transfer-Encoding: binary";
		
		private static const SOURCE_ADOBE_AIR_CLIENT:String = "Adobe Air Client";
		private var _consumerKey:String="";
		private var _consumerSecret:String="";
		private var _accessTokenKey:String="";
		private var _accessTokenSecret:String="";
		private var _pin:String="";
		private var _source:String = SOURCE_ADOBE_AIR_CLIENT;
		private var authHeader:URLRequestHeader;

		private var serviceLoader:Dictionary=new Dictionary();
		private var loaderMap:Dictionary=new Dictionary();

		private var oauthLoader:URLLoader;
		
		/**
		 * @private Used for test purpose.
		 */
		nm_test_internal var lastLoader:URLLoader;
		nm_test_internal var lastRequest:URLRequest;
		
		public function MicroBlog()
		{
			
		}

		/**
		 * consumerKey是一个只写属性，用于验证客户端的合法性，
		 * 必须在调用login之前将其设置为合适值.
		 */
		public function set consumerKey(value:String):void
		{
			if ( value )
			{
				_consumerKey=value;
			} else
			{
				_consumerKey = "";
			}
		}

		/**
		 * consumerSecret是一个只写属性，用于和consumerKey一起验证客户端的合法性，
		 * 必须在调用login之前将其设置为合适值.
		 */
		public function set consumerSecret(value:String):void
		{
			if ( value )
			{
				_consumerSecret=value;
			} else
			{
				_consumerSecret = "";
			}
		}
		/**
		 * pin是用于OAuth认证用的属性，由登陆页面生成.仅在登陆时使用.
		 * 
		 */
		public function set pin(value:String):void
		{
			_pin=value;
			//Case that the saved user come back. 
			//The oauthLoader will not created before login
			//Actually, the application could save last token and
			//reset after the application restarted.
			if ( oauthLoader )
			{
				var url:String=OAUTH_ACCESS_TOKEN_REQUEST_URL;
				var req:URLRequest=signRequest(URLRequestMethod.GET, url, null);
				oauthLoader.load(req);
				_pin = ""; // Just use once.
			}
		}
		
		/**
		 * accessTokenKey是用于OAuth认证的访问资源的token，由用户授权.
		 * 
		 */
		public function set accessTokenKey(value:String):void
		{
			if (null != value)
			{
				_accessTokenKey=value;
			} else
			{
				_accessTokenKey = "";
			}
		}

		public function get accessTokenKey():String
		{
			return _accessTokenKey;
		}
		/**
		 * accessTokenSecret是用于OAuth认证的访问资源的token的密钥.
		 * 
		 */
		public function get accessTokenSecrect():String
		{
			return _accessTokenSecret;
		}
		public function set accessTokenSecrect(value:String):void
		{
			if (null != value)
			{
				_accessTokenSecret=value;
			} else
			{
				_accessTokenSecret = "";
			}
		}
		/**
		 * source是标识客户端来源.必须设置为新浪认证的应用程序id
		 * 
		 */
		public function set source(value:String):void
		{
			_source = StringEncoders.urlEncodeUtf8String(value);
		}
		public function get source():String
		{
			return _source;
		}
		/**
		 * login函数封装了OAuth所要求的验证的三个步骤，
		 * 调用者只需要将新浪微博的用户名和密码
		 * （之前输入的consumerKey和consumerSecret）
		 * 传入函数即可.
		 *
		 * @param userName 是合法的新浪微博用户名.
		 * @param password 是与用户名对应的密码.
		 *
		 * login函数没有返回值，验证结果将采用消息的方式通知api调用者.
		 * @see com.sina.microblog.events.MicroBlogEvent#LOGIN_RESULT
		 *
		 */
		public function login(userName:String=null, password:String=null):void
		{
			if (_accessTokenKey.length > 0 && _accessTokenSecret.length > 0)
			{
				return;
			}

			if (_consumerKey.length > 0 && _consumerSecret.length > 0)
			{
				if (null == oauthLoader)
				{
					oauthLoader=new URLLoader();
					oauthLoader.addEventListener(Event.COMPLETE, oauthLoader_onComplete, false, 0, true);
					oauthLoader.addEventListener(IOErrorEvent.IO_ERROR, oauthLoader_onError, false, 0, true);
					oauthLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, oauthLoader_onSecurityError, false, 0, true);
				}
				var req:URLRequest=signRequest(URLRequestMethod.GET, OAUTH_REQUEST_TOKEN_REQUEST_URL, null);
				oauthLoader.load(req);
			}
			else if (userName != null && password != null)
			{
				var creds:String=userName + ":" + password;
				var encodedCredentials:String=Base64.encode(creds);
				authHeader=new URLRequestHeader("Authorization", "Basic " + encodedCredentials);
				verifyCredentials();
			}

		}

		/**
		 * 返回最新更新的20条公共微博消息.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件<br/>
		 * type为<b>MicroBlogEvent.STATUS_PUBLIC_TIMELINE_RESULT</b><br/>
		 * success为<b>true</b>如果该属性为false，则表示该次操作失败<br/>
		 * result为一个MicroBlogStatus数组，该数组包含了最新的20条微博消息.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.STATUS_PUBLIC_TIMELINE_ERROR</b></p>
		 *
		 */
		public function loadPublicTimeline():void
		{
			addProcessor(PUBLIC_TIMELINE_REQUEST_URL, processStatusArray, MicroBlogEvent.LOAD_PUBLIC_TIMELINE_RESULT, MicroBlogErrorEvent.LOAD_PUBLIC_TIMELINE_ERROR);
			executeRequest(PUBLIC_TIMELINE_REQUEST_URL, getMicroBlogRequest(PUBLIC_TIMELINE_REQUEST_URL, null, URLRequestMethod.GET));
		}

		/**
		 * 返回用户所有关注的用户最新的n条微博消息.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.STATUS_FRIENDS_TIMELINE_RESULT</b><br/>
		 * result为一个MicroBlogStatus数组，该数组包含了所请求的微博消息.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.STATUS_FRIENDS_TIMELINE_ERROR</b><br/></p>
		 *
		 * @param sinceID 请求大于该id的所有消息更新，默认值为0，表示不限制.
		 * @param maxID 请求小于该id的所有消息更新，默认为0，表示不限制.
		 * @param count 请求的页大小，即一页包含多少条记录；默认值0，表示使用服务器默认分页大小.
		 * @param page 请求的页序号，默认值0，返回第一页.
		 *
		 */
		public function loadFriendsTimeline(sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
		{
			addProcessor(FRIENDS_TIMELINE_REQUEST_URL, processStatusArray, MicroBlogEvent.LOAD_FRIENDS_TIMELINE_RESULT, MicroBlogErrorEvent.LOAD_FRIENDS_TIMELINE_ERROR);
			var url:String=FRIENDS_TIMELINE_REQUEST_URL;
			var params:Object=new Object();
			makeQueryCombinatory(params, sinceID, maxID, count, page);
			executeRequest(FRIENDS_TIMELINE_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 返回用户发布的最新的n条微博消息.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.STATUS_USER_TIMELINE_RESULT</b><br/>
		 * result为一个MicroBlogStatus数组，该数组包含了所请求的微博消息.
		 * 由于分页限制，最多只能返回用户最新的300条微博信息</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.STATUS_USER_TIMELINE_ERROR</b></p>
		 *
		 * @param id 可选参数. 根据指定用户UID或用户帐号来返回微博信息.
		 * @param userID 可选参数. 指定用户UID来返回微博信息，主要是用来区分用户UID跟用户账号一样，产生歧义的时候，特别是在用户账号为数字导致和用户Uid发生歧义.
		 * @param screenName 可选参数，指定用户的微博昵称，主要是用来区分用户UID跟用户账号一样，产生歧义的时候。
		 * @param sinceID 请求大于该id的所有消息更新，默认值为0，表示不限制.
		 * @param maxID 请求小于该id的所有消息更新，默认为0，表示不限制.
		 * @param count 请求的页大小，即一页包含多少条记录；默认值0，表示使用服务器默认分页大小.
		 * @param page 请求的页序号，默认值0，返回第一页.
		 *
		 *
		 */
		public function loadUserTimeline(id:*=null, userID:uint=0, screenName:String=null, sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
		{
			//TO-DO: if the parameter equals to zero, don't include this parameter when build request url.
			addProcessor(USER_TIMELINE_REQUEST_URL, processStatusArray, MicroBlogEvent.LOAD_USER_TIMELINE_RESULT, MicroBlogErrorEvent.LOAD_USER_TIMELINE_ERROR);
			var user:String;
			if (id)
			{
				user="/" + String(id);
			}
			else
			{
				user="";
			}
			var url:String=USER_TIMELINE_REQUEST_URL.replace("$user", user);
			var params:Object=new Object();
			makeUserParams(params, userID, screenName, -1);
			makeQueryCombinatory(params, sinceID, maxID, count, page);

			executeRequest(USER_TIMELINE_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 返回最近n条提及我的微博消息.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.STATUS_MENTIONS_RESULT</b><br/>
		 * result为一个MicroBlogStatus数组，该数组包含了所请求的微博消息.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.STATUS_MENTIONS_ERROR</b></p>
		 *
		 * @param sinceID 请求大于该id的所有消息更新，默认值为0，表示不限制.
		 * @param maxID 请求小于该id的所有消息更新，默认为0，表示不限制.
		 * @param count 请求的页大小，即一页包含多少条记录；默认值0，表示使用服务器默认分页大小.
		 * @param page 请求的页序号，默认值0，返回第一页.
		 *
		 */
		public function loadMentions(sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
		{
			//TO-DO: if the parameter equals to zero, don't include this parameter when build request url.
			addProcessor(MENTIONS_REQUEST_URL, processStatusArray, MicroBlogEvent.LOAD_MENSIONS_RESULT, MicroBlogErrorEvent.LOAD_MENSIONS_ERROR);
			var url:String=MENTIONS_REQUEST_URL;
			var params:Object=new Object();
			makeQueryCombinatory(params, sinceID, maxID, count, page);
			executeRequest(MENTIONS_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 返回最近n条评论.
		 * 
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.STATUS_COMMENTS_TIMELINE_RESULT</b><br/>
		 * result为一个MicroBlogStatus数组，该数组包含了所请求的微博消息.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.STATUS_COMMENTS_TIMELINE_ERROR</b></p>
		 *
		 * @param sinceID 请求大于该id的所有消息更新，默认值为0，表示不限制.
		 * @param maxID 请求小于该id的所有消息更新，默认为0，表示不限制.
		 * @param count 请求的页大小，即一页包含多少条记录；默认值0，表示使用服务器默认分页大小.
		 * @param page 请求的页序号，默认值0，返回第一页.
		 *
		 */
		public function loadCommentsTimeline(sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
		{
			addProcessor(COMMENTS_TIMELINE_REQUEST_URL, processCommentArray, MicroBlogEvent.LOAD_COMMENTS_TIMELINE_RESULT, MicroBlogErrorEvent.LOAD_COMMENTS_TIMELINE_ERROR);
			var url:String=COMMENTS_TIMELINE_REQUEST_URL;
			var params:Object=new Object();
			makeQueryCombinatory(params, sinceID, maxID, count, page);
			executeRequest(COMMENTS_TIMELINE_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 返回我发表的评论.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.STATUS_COMMENTS_BY_ME_RESULT</b><br/>
		 * result为一个MicroBlogStatus数组，该数组包含了所请求的微博消息.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.STATUS_COMMENTS_TIMELINE_ERROR</b></p>
		 *
		 * @param sinceID 请求大于该id的所有消息更新，默认值为0，表示不限制.
		 * @param maxID 请求小于该id的所有消息更新，默认为0，表示不限制.
		 * @param count 请求的页大小，即一页包含多少条记录；默认值0，表示使用服务器默认分页大小.
		 * @param page 请求的页序号，默认值0，返回第一页.
		 *
		 */
		public function loadMyComments(sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
		{
			addProcessor(COMMENTS_BY_ME_REQUEST_URL, processCommentArray, MicroBlogEvent.LOAD_MY_COMMENTS_RESULT, MicroBlogErrorEvent.LOAD_MY_COMMENTS_ERROR);
			var url:String=COMMENTS_BY_ME_REQUEST_URL;
			var params:Object=new Object();
			makeQueryCombinatory(params, sinceID, maxID, count, page);
			executeRequest(COMMENTS_BY_ME_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 返回指定微博的最新n条评论.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.STATUS_COMMENTS_RESULT</b><br/>
		 * result为一个MicroBlogStatus数组，该数组包含了所请求的微博消息.</p>
		 *
		 * @param id 必选参数，指定微博ID.
		 * @param count 请求的页大小，即一页包含多少条记录；默认值0，表示使用服务器默认分页大小.
		 * @param page 请求的页序号，默认值0，返回第一页.
		 */
		public function loadCommentList(id:uint, count:uint=0, page:uint=0):void
		{
			addProcessor(COMMENTS_REQUEST_URL, processCommentArray, MicroBlogEvent.LOAD_COMMENTS_RESULT, MicroBlogErrorEvent.LOAD_COMMENTS_ERROR);
			var url:String=COMMENTS_REQUEST_URL;
			var params:Object=new Object();
			params[ID]=id;
			makeQueryCombinatory(params, 0, 0, count, page);
			executeRequest(COMMENTS_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 批量统计微薄的评论数，转发数.单次最多获取100个.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.STATUS_COUNTS_RESULT</b><br/>
		 * result为一个MicroBlogCounts实例.</p>
		 *
		 * @param ids 必选参数，指定微博ID数组.
		 *
		 */
		public function loadStatusCounts(ids:Array):void
		{
			addProcessor(STATUS_COUNTS_REQUEST_URL, processCounts, MicroBlogEvent.LOAD_STATUS_COUNTS_RESULT, MicroBlogErrorEvent.LOAD_STATUS_COUNTS_ERROR);
			var idsParam:String="";
			
			if (null == ids || ids.length == 0)
			{
				return;
			}
			var len:int=ids.length - 1;
			for (var i:int=0; i < len; ++i)
			{
				idsParam+=ids[i].toString() + ",";
			}
			idsParam+=ids[len].toString();
			var params:Object=new Object();
			params["ids"]=idsParam;
			var url:String=STATUS_COUNTS_REQUEST_URL;
			executeRequest(STATUS_COUNTS_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 获取单条ID的微博信息，作者信息将同时返回.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.SHOW_STATUS_RESULT</b><br/>
		 * result为一个MicroBlogStatus实例.</p>
		 *
		 * @param id 必选参数，指定微博消息ID.
		 *
		 */
		public function loadStatusInfo(id:uint):void
		{
			addProcessor(SHOW_STATUS_REQUEST_URL, processStatus, MicroBlogEvent.LOAD_STATUS_INFO_RESULT, MicroBlogErrorEvent.LOAD_STATUS_INFO_ERROR);
			var url:String=SHOW_STATUS_REQUEST_URL.replace("$id", id);
			executeRequest(SHOW_STATUS_REQUEST_URL, getMicroBlogRequest(url, null, URLRequestMethod.GET));
		}

		/**
		 * 发布一条微博信息.为防止重复，发布的信息与当前最新信息一样话，将会被忽略.
		 *
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.UPDATE_STATUS_RESULT</b><br/>
		 * result为一个MicroBlogStatus实例.</p>
		 *
		 * @param status 必选参数，要更新的微博信息,信息内容部超过140个汉字.
		 * @param filename 可选参数，上传的jpeg文件名.
		 * @param imgData 可选参数，为需要上传的jpeg文件数据，为空则不上传图片.
		 *
		 * 如果没有登录或超过发布上限，将返回错误
		 * 系统将忽略重复发布的信息.每次发布将比较最后一条发布消息，如果一样将被忽略.因此用户不能连续提交相同信息.
		 */
		public function updateStatus(status:String, filename:String=null, imgData:ByteArray=null):void
		{
			addProcessor(UPDATE_STATUS_REQUEST_URL, processStatus, MicroBlogEvent.UPDATE_STATUS_RESULT, MicroBlogErrorEvent.UPDATE_STATUS_ERROR);
			var req:URLRequest;
			var params:URLVariables=new URLVariables();
			
			if ( status )
			{
				params.status= encodeMsg(status);
			} else
			{
				if ( imgData == null )
				{
					return;
				}
			}
			
			var url:String;

			if (imgData)
			{
				url=UPDATE_STATUS_WITH_IMAGE_REQUEST_URL;
				req=getMicroBlogRequest(url, params, URLRequestMethod.POST);
				var boundary:String=makeBoundary();
				req.contentType=MULTIPART_FORMDATA + boundary;
				req.data=makeMultipartPostData(boundary, "pic", filename, imgData, params);
			}
			else
			{
				
				url=UPDATE_STATUS_REQUEST_URL;
				req=getMicroBlogRequest(url, params, URLRequestMethod.POST);
				req.data=params;
			}
			executeRequest(UPDATE_STATUS_REQUEST_URL, req);

		}

		/**
		 * 返回发布一条带图片的微博信息的<code>URLRequest对象</code>.
		 *
		 * 
		 * <p>如果消息成功发送，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.UPDATE_STATUS_RESULT</b><br/>
		 * result为一个MicroBlogStatus实例.</p>
		 *
		 *
		 * @return <code>URLRequest</code>对象，用于在flash中用File对象上传图片，在调用File对象的upload时uploadDataFieldName必须为pic。
		 *
		 * 如果没有登录或超过发布上限，将返回错误
		 * 系统将忽略重复发布的信息.每次发布将比较最后一条发布消息，如果一样将被忽略.因此用户不能连续提交相同信息.
		 *
		 * @see #updateStatus()
		 */
		public function getUploadImageRequest(status:String):URLRequest
		{
			var req:URLRequest;
			
			var url:String=UPDATE_STATUS_WITH_IMAGE_REQUEST_URL;
			var data:URLVariables=new URLVariables();
			data.status=encodeMsg(status);
			req=getMicroBlogRequest(url, data, URLRequestMethod.POST);
			req.data=data;
			return req;
		}

		/**
		 * 删除微博信息.注意：只能删除自己发布的信息.
		 * 
		 * <p> 如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.DELETE_STATUS_RESULT</b><br/>
		 * result为一个MicroBlogStatus实例.</p>
		 *
		 * @param id 必填参数，要删除的微博信息ID.
		 *
		 */
		public function deleteStatus(id:uint):void
		{
			addProcessor(DELETE_STATUS_REQUEST_URL, processStatus, MicroBlogEvent.DELETE_STATUS_RESULT, MicroBlogErrorEvent.DELETE_STATUS_ERROR);
			var url:String=DELETE_STATUS_REQUEST_URL.replace("$id", id);
			var postData:URLVariables = new URLVariables();
			var req:URLRequest = getMicroBlogRequest(url, postData, URLRequestMethod.POST);
			req.data = postData;
			executeRequest(DELETE_STATUS_REQUEST_URL, req);
			
		}

		/**
		 * 转发一条微博信息.为防止重复，发布的信息与当前最新信息一样话，将会被忽略.
		 *
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.REPOST_STATUS_RESULT</b><br/>
		 * result为一个MicroBlogStatus实例.</p>
		 *
		 * @param id 必填参数，转发的微博ID.
		 * @param status 可选参数，要更新的微博信息,信息内容部超过140个汉字.
		 * 
		 * <p>如果没有登录或超过发布上限，将返回错误
		 * 系统将忽略重复发布的信息.每次发布将比较最后一条发布消息，如果一样将被忽略.因此用户不能连续提交相同信息.
		 * </p>
		 */
		public function repostStatus(id:uint, status:String=null):void
		{
			addProcessor(REPOST_STATUS_REQUEST_URL, processStatus, MicroBlogEvent.REPOST_STATUS_RESULT, MicroBlogErrorEvent.REPOST_STATUS_ERROR);

			var variable:URLVariables=new URLVariables();
			variable.id=id;
			if (status && status.length > 0)
			{
				variable.status=encodeMsg(status);
			}
			var req:URLRequest=getMicroBlogRequest(REPOST_STATUS_REQUEST_URL, variable, URLRequestMethod.POST);
			req.data=variable;
			executeRequest(REPOST_STATUS_REQUEST_URL, req);
		}

		/**
		 * 对一条微博信息进行评论.为防止重复，发布的信息与当前最新信息一样话，将会被忽略.
		 *
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件
		 * type为<b>MicroBlogEvent.COMMENT_STATUS_RESULT</b><br/>
		 * result为一个MicroBlogComment实例.</p>
		 *
		 * <p>如果没有登录或超过发布上限，将返回错误<br/>
		 * 系统将忽略重复发布的信息.每次发布将比较最后一条发布消息，如果一样将被忽略.因此用户不能连续提交相同信息.</p>
		 *
		 * @param id 必填参数， 要评论的微博ID.
		 * @param comment 必选参数，要更新的微博信息,信息内容部超过140个汉字.
		 * @param cid 选填参数，要评论的评论ID.
		 *
		 */
		public function commentStatus(id:uint, comment:String, cid:uint=0):void
		{
			addProcessor(COMMENT_STATUS_REQUEST_URL, processComment, MicroBlogEvent.COMMENT_STATUS_RESULT, MicroBlogErrorEvent.COMMENT_STATUS_ERROR);

			var variable:URLVariables=new URLVariables();
			variable.id=id;
			if (comment )
			{
				variable.comment=encodeMsg(comment);
			}
			if (cid > 0)
			{
				variable.cid=cid;
			}
			var req:URLRequest=getMicroBlogRequest(COMMENT_STATUS_REQUEST_URL, variable, URLRequestMethod.POST);
			req.data=variable;
			executeRequest(COMMENT_STATUS_REQUEST_URL, req);
		}

		/**
		 * 删除评论.注意：只能删除自己发布的信息.
		 *
		 * <p> 如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.DELETE_STATUS_COMMENT_RESULT</b><br/>
		 * result为一个MicroBlogComment实例.</p>
		 *
		 * @param id 必填参数，要删除的微博评论信息ID.
		 *
		 */
		public function deleteComment(id:uint):void
		{
			addProcessor(DELETE_COMMENT_REQUEST_URL, processComment, MicroBlogEvent.DELETE_COMMENT_RESULT, MicroBlogErrorEvent.DELETE_COMMENT_ERROR);
			var url:String=DELETE_COMMENT_REQUEST_URL.replace("$id", id);
			var postData:URLVariables = new URLVariables();
			var req:URLRequest = getMicroBlogRequest(url, postData, URLRequestMethod.POST);
			req.data = postData;
			executeRequest(DELETE_COMMENT_REQUEST_URL, req);
		}

		/**
		 * 对一条微博评论信息进行回复.为防止重复，发布的信息与当前最新信息一样话，将会被忽略.
		 *
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.REPLY_STATUS_RESULT</b><br/>
		 * result为一个MicroBlogStatus实例.</p>
		 *
		 * @param id 必填参数， 要评论的微博消息ID.
		 * @param comment 必选参数，要更新的微博信息,信息内容部超过140个汉字.
		 * @param cid 必选参数，要评论的评论ID.
		 * 
		 * <p>如果没有登录或超过发布上限，将返回错误
		 * 系统将忽略重复发布的信息.每次发布将比较最后一条发布消息，如果一样将被忽略.因此用户不能连续提交相同信息.
		 * </p>
		 */
		public function replyStatus(id:uint, comment:String, cid:uint):void
		{
			addProcessor(REPLY_STATUS_REQUEST_URL, processComment, MicroBlogEvent.REPLY_STATUS_RESULT, MicroBlogErrorEvent.REPLY_STATUS_ERROR);
			var variable:URLVariables=new URLVariables();
			variable.id=id;
			if ( comment )
			{
				variable.comment=encodeMsg(comment);
			}
			variable.cid=cid;
			var req:URLRequest=getMicroBlogRequest(REPLY_STATUS_REQUEST_URL, variable, URLRequestMethod.POST);
			req.data=variable;
			executeRequest(REPLY_STATUS_REQUEST_URL, req);
		}

		/**
		 * 按用户UID或昵称返回用户资料，同时也将返回用户的最新发布的微博.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.SHOW_USERS_RESULT</b><br/>
		 * result为一个MicroBlogUser实例.</p>
		 *
		 * @param user 用户UID或用户帐号.
		 * @param userID 指定用户UID,主要是用来区分用户UID跟用户账号一样，产生歧义的时候，特别是在用户账号为数字导致和用户Uid发生歧义.
		 * @param screenName 指定微博昵称，主要是用来区分用户UID跟用户账号一样，产生歧义的时候.
		 *
		 * <br/>
		 * <b>以上三个参数必须至少给一个</b>
		 * 为了保护用户隐私，只有用户设置了公开或对粉丝设置了公开的数据才会返回.
		 */
		public function loadUserInfo(user:String=null, userID:uint=0, screenName:String=null):void
		{
			addProcessor(LOAD_USER_INFO_REQUEST_URL, processUser, MicroBlogEvent.LOAD_USER_INFO_RESULT, MicroBlogErrorEvent.LOAD_USER_INFO_ERROR);
			if (user && user.length > 0)
			{
				user="/" + user;
			}
			else
			{
				user="";
			}
			var url:String=LOAD_USER_INFO_REQUEST_URL.replace("$user", user);
			var params:Object=new Object();
			makeUserParams(params, userID, screenName, -1);
			executeRequest(LOAD_USER_INFO_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));

		}

		/**
		 * 返回用户关注实例列表，并返回最新微博文章.按关注人的关注时间倒序返回，
		 * 每次返回100个,通过cursor参数来取得多于100的关注人.
		 * 也可以通过ID,nickname,user_id参数来获取其他人的关注人列表.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.FRIENDS_RESULT</b><br/>
		 * result为一个MicroBlogUser数组.</p>
		 *
		 * @param user 用户UID或用户帐号.
		 * @param userID 指定用户UID,主要是用来区分用户UID跟用户账号一样，产生歧义的时候，特别是在用户账号为数字导致和用户Uid发生歧义.
		 * @param screenName 指定微博昵称，主要是用来区分用户UID跟用户账号一样，产生歧义的时候.
		 * @param cursor 选填参数. 单页只能包含100个关注列表，为了获取更多则cursor默认从-1开始，通过增加或减少cursor来获取更多的关注列表.
		 *
		 * <p>为了保护用户隐私，只有用户设置了公开或对粉丝设置了公开的数据才会返回.</p>
		 */
		public function loadFriendsInfo(user:String=null, userID:uint=0, screenName:String=null, cursor:Number=-1):void
		{
			addProcessor(LOAD_FRIENDS_INFO_REQUEST_URL, processUserArray, MicroBlogEvent.LOAD_FRIENDS_INFO_RESULT, MicroBlogErrorEvent.LOAD_FRIENDS_INFO_ERROR);
			if (user && user.length > 0)
			{
				user="/" + user;
			}
			else
			{
				user="";
			}
			var url:String=LOAD_FRIENDS_INFO_REQUEST_URL.replace("$user", user);
			var params:Object=new Object();
			makeUserParams(params, userID, screenName, cursor);
			executeRequest(LOAD_FRIENDS_INFO_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 返回用户的粉丝列表，并返回粉丝的最新微博.按粉丝的关注时间倒序返回，
		 * 每次返回100个,通过cursor参数来取得多于100的粉丝.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.FOLLOWERS_RESULT</b><br/>
		 * result为一个MicroBlogUser数组.</p>
		 *
		 * @param user 用户UID或用户帐号.
		 * @param userID 指定用户UID,主要是用来区分用户UID跟用户账号一样，产生歧义的时候，特别是在用户账号为数字导致和用户Uid发生歧义.
		 * @param screenName 指定微博昵称，主要是用来区分用户UID跟用户账号一样，产生歧义的时候.
		 * @param cursor 选填参数. 单页只能包含100个关注列表，为了获取更多则cursor默认从-1开始，通过增加或减少cursor来获取更多的关注列表.
		 *
		 * <p>为了保护用户隐私，只有用户设置了公开或对粉丝设置了公开的数据才会返回.</p>
		 */
		public function loadFollowersInfo(user:String=null, userID:uint=0, screenName:String=null, cursor:int=-1):void
		{
			addProcessor(LOAD_FOLLOWERS_INFO_REQUEST_URL, processUserArray, MicroBlogEvent.LOAD_FOLLOWERS_INFO_RESULT, MicroBlogErrorEvent.LOAD_FOLLOWERS_INFO_ERROR);
			if (user && user.length > 0)
			{
				user="/" + user;
			}
			else
			{
				user="";
			}
			var url:String=LOAD_FOLLOWERS_INFO_REQUEST_URL.replace("$user", user);
			var params:Object=new Object();
			makeUserParams(params, userID, screenName, cursor);
			executeRequest(LOAD_FOLLOWERS_INFO_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 返回用户的最新n条私信.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p> 如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.DIRECT_MESSAGES_RESULT</b><br/>
		 * result为一个MicroBlogDirectMessage数组.</p>
		 *
		 * @param sinceID 请求大于该id的所有消息更新，默认值为0，表示不限制.
		 * @param maxID 请求小于该id的所有消息更新，默认为0，表示不限制.
		 * @param count 请求的页大小，即一页包含多少条记录；默认值0，表示使用服务器默认分页大小.
		 * @param page 请求的页序号，默认值0，返回第一页.
		 *
		 * <p>为了保护用户隐私，只有用户设置了公开或对粉丝设置了公开的数据才会返回.</p>
		 */
		public function loadDirectMessagesReceived(sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
		{
			addProcessor(LOAD_DIRECT_MESSAGES_RECEIVED_REQUEST_URL, processDirectMessageArray, MicroBlogEvent.LOAD_DIRECT_MESSAGES_RECEIVED_RESULT, MicroBlogErrorEvent.LOAD_DIRECT_MESSAGES_RECEIVED_ERROR);
			var url:String=LOAD_DIRECT_MESSAGES_RECEIVED_REQUEST_URL;
			var params:Object=new Object();
			makeQueryCombinatory(params, sinceID, maxID, count, page);
			executeRequest(LOAD_DIRECT_MESSAGES_RECEIVED_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 返回登录用户已发送最新n条私信.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p> 如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.SENT_DIRECT_MESSAGES_RESULT</b><br/>
		 * result为一个MicroBlogDirectMessage数组.</p>
		 *
		 * @param sinceID 请求大于该id的所有消息更新，默认值为0，表示不限制.
		 * @param maxID 请求小于该id的所有消息更新，默认为0，表示不限制.
		 * @param count 请求的页大小，即一页包含多少条记录；默认值0，表示使用服务器默认分页大小.
		 * @param page 请求的页序号，默认值0，返回第一页.
		 *
		 * <p>为了保护用户隐私，只有用户设置了公开或对粉丝设置了公开的数据才会返回.</p>
		 */
		public function loadDirectMessagesSent(sinceID:uint=0, maxID:uint=0, count:uint=0, page:uint=0):void
		{
			addProcessor(LOAD_DIRECT_MESSAGES_SENT_REQUEST_URL, processDirectMessageArray, MicroBlogEvent.LOAD_DIRECT_MESSAGES_SENT_RESULT, MicroBlogErrorEvent.LOAD_DIRECT_MESSAGES_SENT_ERROR);
			var url:String=LOAD_DIRECT_MESSAGES_SENT_REQUEST_URL;
			var params:Object=new Object();
			makeQueryCombinatory(params, sinceID, maxID, count, page);
			
			executeRequest(LOAD_DIRECT_MESSAGES_SENT_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 返发送一条私信.必须包含参数user和message,
		 * userID和screenName必须选一个.
		 *
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.NEW_DIRECT_MESSAGES_RESULT</b><br/>
		 * result为一个MicroBlogDirectMessage实例.</p>
		 *
		 * @param user 用户UID或用户帐号.
		 * @param message 必须参数. 要发生的消息内容，文本大小必须小于140个汉字.
		 * @param userID 指定用户UID,主要是用来区分用户UID跟用户账号一样，产生歧义的时候，特别是在用户账号为数字导致和用户Uid发生歧义.
		 * @param screenName 指定微博昵称，主要是用来区分用户UID跟用户账号一样，产生歧义的时候.
		 *
		 */
		public function sendDirectMessage(user:String, message:String, userID:uint=0, screenName:String=null):void
		{
			//curl -u user:password -d "text=all your bases are belong to us&user=user_2" http://api.t.sina.com.cn/direct_messages/new.xml
			addProcessor(SEND_DIRECT_MESSAGE_REQUEST_URL, processDirectMessage, MicroBlogEvent.SEND_DIRECT_MESSAGE_RESULT, MicroBlogErrorEvent.SEND_DIRECT_MESSAGE_ERROR);
			if (userID == 0 && screenName == null)
			{
				var e:MicroBlogErrorEvent=new MicroBlogErrorEvent(MicroBlogErrorEvent.SEND_DIRECT_MESSAGE_ERROR);
				e.message="参数错误";
				dispatchEvent(e);
			}

			var data:URLVariables=new URLVariables();
			if (userID > 0)
			{
				data.user_id=userID;
			}
			if (screenName)
			{
				data.screen_name=screenName;
			}
			data.id = user;
			data.text = encodeMsg(message);
			var req:URLRequest=getMicroBlogRequest(SEND_DIRECT_MESSAGE_REQUEST_URL, data, URLRequestMethod.POST);
			req.data=data;
			executeRequest(SEND_DIRECT_MESSAGE_REQUEST_URL, req);
		}

		/**
		 * 按ID删除私信.操作用户必须为私信的接收人.
		 *
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.DELETE_DIRECT_MESSAGES_RESULT</b><br/>
		 * result为一个MicroBlogDirectMessage实例.</p>
		 *
		 * @param id 必填参数，要删除的私信主键ID.
		 *
		 */
		public function deleteDirectMessage(id:uint):void
		{
			//curl -u user:password --http-request DELETE http://api.t.sina.com.cn/direct_messages/destroy/88619848.xml
			addProcessor(DELETE_DIRECT_MESSAGE_REQUEST_URL, processDirectMessage, MicroBlogEvent.DELETE_DIRECT_MESSAGE_RESULT, MicroBlogErrorEvent.DELETE_DIRECT_MESSAGE_ERROR);
			var url:String=DELETE_DIRECT_MESSAGE_REQUEST_URL.replace("$id", id);
			var postData:URLVariables = new URLVariables();
			var req:URLRequest = getMicroBlogRequest(url, postData, URLRequestMethod.POST);
			req.data = postData;
			executeRequest(DELETE_DIRECT_MESSAGE_REQUEST_URL, req);
		}

		/**
		 * 关注一个用户.成功则返回关注人的资料，
		 * 失败则返回一条字符串的说明.
		 *
		 * <p> 如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.CREATE_FRIENDSHIPS_RESULT</b><br/>
		 * result为一个MicroBlogUser实例.</p>
		 *
		 * @param user 用户UID或用户帐号.
		 * @param userID 主要是用来区分用户UID跟用户账号一样，产生歧义的时候，特别是在用户账号为数字导致和用户Uid发生歧义.
		 * @param screenName 指定微博昵称，主要是用来区分用户UID跟用户账号一样，产生歧义的时候.
		 * @param isFollow 可选参数.将是自己粉丝的用户加为关注.
		 *
		 */
		public function follow(user:String, userID:uint, screenName:String, isFollow:Boolean=true):void
		{
			//TO-DO: if the parameter equals to zero, don't include this parameter when build request url.
			addProcessor(FOLLOW_REQUEST_URL, processUser, MicroBlogEvent.FOLLOW_RESULT, MicroBlogErrorEvent.FOLLOW_ERROR);
			if (user && user.length > 0)
			{
				user="/" + user;
			} else
			{
				user="";
			}
			var url:String=FOLLOW_REQUEST_URL.replace("$user", user);
			var params:URLVariables=new URLVariables();
			if ( userID > 0 )
			{
				params.user_id = userID;
			}
			if ( screenName && screenName.length > 0 )
			{
				params.screen_name = screenName;
			}
			params.follow = isFollow;
			
			var req:URLRequest=getMicroBlogRequest(url, params, URLRequestMethod.POST);
			req.data = params;
			executeRequest(FOLLOW_REQUEST_URL, req);
		}

		/**
		 * 取消关注某用户.成功则返回被取消关注人的资料，
		 * 失败则返回一条字符串的说明.
		 *
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.DESTROY_FRIENDSHIPS_RESULT</b><br/>
		 * result为一个MicroBlogUser实例.</p>
		 *
		 * @param user 用户UID或用户帐号.
		 * @param userID 主要是用来区分用户UID跟用户账号一样，产生歧义的时候，特别是在用户账号为数字导致和用户Uid发生歧义.
		 * @param screenName 指定微博昵称，主要是用来区分用户UID跟用户账号一样，产生歧义的时候.
		 *
		 */
		public function cancelFollowing(user:String, userID:uint, screenName:String):void
		{
			//TO-DO: if the parameter equals to zero, don't include this parameter when build request url.
			addProcessor(CANCEL_FOLLOWING_REQUEST_URL, processUser, MicroBlogEvent.CANCEL_FOLLOWING_RESULT, MicroBlogErrorEvent.CANCEL_FOLLOWING_ERROR);
			if (user && user.length > 0)
			{
				user="/" + user;
			} else
			{
				user="";
			}
			var url:String=CANCEL_FOLLOWING_REQUEST_URL.replace("$user", user);
			var params:URLVariables=new URLVariables();
			if ( userID > 0 )
			{
				params.user_id = userID;
			}
			if ( screenName && screenName.length > 0 )
			{
				params.screen_name = screenName;
			}
			
			var req:URLRequest=getMicroBlogRequest(url, params, URLRequestMethod.POST);
			req.data = params;
			executeRequest(CANCEL_FOLLOWING_REQUEST_URL, req);
		}

		/**
		 * 返回两个用户关系的详细情况.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.CHECK_FRIENDSHIPS_RESULT</b><br/>
		 * result为<code>MicroBlogUsersRelationship</code>值.</p>
		 *
		 * @param targetID 选填参数，要判断的目标用户的uid.
		 * @param targetScreenName  选填参数，要判断的目标用户的昵称.targetID和targetScreenName两个参数必须填一个.
		 * @param sourceID 选填参数，要判断的源用户的uid
		 * @param sourceScreenName 选填参数，要判断的源用户的昵称.如果sourceID和sourceScreenName均未填，则以当前用户为源用户
		 *
		 */
		public function checkIsFollowing(targetID:uint=0, targetScreenName:String=null, sourceID:uint=0, sourceScreenName:String=null):void
		{
			addProcessor(CHECK_IS_FOLLOWING_REQUEST_URL, processRelationship, MicroBlogEvent.CHECK_IS_FOLLOWING_RESULT, MicroBlogErrorEvent.CHECK_IS_FOLLOWING_ERROR);
			var params:Object=new Object();
			var needExecute:Boolean=false;
			if (targetID > 0)
			{
				params[TARGET_ID]=targetID;
				needExecute=true;
			}
			if (targetScreenName && targetScreenName.length > 0)
			{
				params[TARGET_SCREEN_NAME]=StringEncoders.urlEncodeUtf8String(targetScreenName);
				needExecute=true;
			}
			if (!needExecute)
			{
				return;
			}
			if (sourceID > 0)
			{
				params[SOURCE_ID]=sourceID;
			}
			if (sourceScreenName && sourceScreenName.length > 0)
			{
				params[SOURCE_SCREEN_NAME]=StringEncoders.urlEncodeUtf8String(sourceScreenName);
			}
			var url:String=CHECK_IS_FOLLOWING_REQUEST_URL;
			executeRequest(CHECK_IS_FOLLOWING_REQUEST_URL,getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 返回用户关注对象的user_id列表.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.LOAD_FRIENDS_ID_LIST_RESULT</b><br/>
		 * result为<code>uint数组</code>实例.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.LOAD_FRIENDS_ID_LIST_ERROR</b><br/>
		 * message为错误描述.</p>
		 *
		 * @param user 用户UID或用户帐号.
		 * @param userID 主要是用来区分用户UID跟用户账号一样，产生歧义的时候，特别是在用户账号为数字导致和用户Uid发生歧义.
		 * @param screenName 指定微博昵称，主要是用来区分用户UID跟用户账号一样，产生歧义的时候.
		 * @param cursor 选填参数. 单页只能包含5000个id，为了获取更多则cursor默认从-1开始，通过增加或减少cursor来获取更多的关注列表.
		 * @param count 可选参数. 每次返回的最大记录数（即页面大小），不大于5000。
		 */
		public function loadFriendsIDList(user:String, userID:uint=0, screenName:String=null, cursor:Number=-1, count:uint=5000):void
		{
			addProcessor(LOAD_FRIENDS_ID_LIST_REQUEST_URL, processIDSArray, MicroBlogEvent.LOAD_FRIENDS_ID_LIST_RESULT, MicroBlogErrorEvent.LOAD_FRIENDS_ID_LIST_ERROR);
			if (user && user.length > 0)
			{
				user="/" + user;
			}
			else
			{
				user="";
			}
			var url:String=LOAD_FRIENDS_ID_LIST_REQUEST_URL.replace("$user", user);
			var params:Object=new Object();
			makeUserParams(params, userID, screenName, cursor);
			params["count"] = count;
			executeRequest(LOAD_FRIENDS_ID_LIST_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 返回用户粉丝的user_id列表.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.LOAD_FOLLOWERS_ID_LIST_RESULT</b><br/>
		 * result为<code>uint数组</code>实例.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.LOAD_FOLLOWERS_ID_LIST_ERROR</b><br/>
		 * message为错误描述.</p>
		 *
		 * @param user 用户UID或用户帐号.
		 * @param userID 主要是用来区分用户UID跟用户账号一样，产生歧义的时候，特别是在用户账号为数字导致和用户Uid发生歧义.
		 * @param screenName 指定微博昵称，主要是用来区分用户UID跟用户账号一样，产生歧义的时候.
		 * @param cursor 选填参数. 单页只能包含5000个id，为了获取更多则cursor默认从-1开始，通过增加或减少cursor来获取更多的关注列表.
		 * @param count 可选参数. 每次返回的最大记录数（即页面大小），不大于5000。
		 */
		public function loadFollowersIDList(user:String, userID:uint=0, screenName:String=null, cursor:Number=-1, count:uint=5000):void
		{
			addProcessor(LOAD_FOLLOWERS_ID_LIST_REQUEST_URL, processIDSArray, MicroBlogEvent.LOAD_FOLLOWERS_ID_LIST_RESULT, MicroBlogErrorEvent.LOAD_FOLLOWERS_ID_LIST_ERROR);
			if (user && user.length>0)
			{
				user="/" + user;
			}
			else
			{
				user="";
			}
			var url:String=LOAD_FOLLOWERS_ID_LIST_REQUEST_URL.replace("$user", user);
			var params:Object=new Object();
			makeUserParams(params, userID, screenName, cursor);
			params["count"]=count;
			executeRequest(LOAD_FOLLOWERS_ID_LIST_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 判断用户身份是否合法.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.VERIFY_CREDENTIALS_RESULT</b><br/>
		 * result为<code>MicroBlogUser</code>实例.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.VERIFY_CREDENTIALS_ERROR</b><br/>
		 * message为错误描述.</p>
		 *
		 */
		public function verifyCredentials():void
		{
			//TO-DO: if the parameter equals to zero, don't include this parameter when build request url.
			//curl -u user:password http://api.t.sina.com.cn/account/verify_credentials.xml
			addProcessor(VERIFY_CREDENTIALS_REQUEST_URL, processUser, MicroBlogEvent.VERIFY_CREDENTIALS_RESULT, MicroBlogErrorEvent.VERIFY_CREDENTIALS_ERROR);
			executeRequest(VERIFY_CREDENTIALS_REQUEST_URL, getMicroBlogRequest(VERIFY_CREDENTIALS_REQUEST_URL, null));
		}

		/**
		 * 获取当前的API调用次数限制.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.RATE_LIMIT_INFO_RESULT</b><br/>
		 * result为<code>MicroBlogRateInfo</code>实例.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.RATE_LIMIT_INFO_ERROR</b><br/>
		 * message为错误描述.</p>
		 *
		 */
		public function getRateLimitInfo():void
		{
			//curl -u user:password http://api.t.sina.com.cn/account/rate_limit_status.xml
			addProcessor(GET_RATE_LIMIT_STATUS_REQUEST_URL, processRateLimit, MicroBlogEvent.GET_RATE_LIMIT_STATUS_RESULT, MicroBlogErrorEvent.GET_RATE_LIMIT_STATUS_ERROR);
			executeRequest(GET_RATE_LIMIT_STATUS_REQUEST_URL, getMicroBlogRequest(GET_RATE_LIMIT_STATUS_REQUEST_URL, null) );
		}

		/**
		 * 登陆用户退出.
		 *
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.LOGOUT_RESULT</b><br/></p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.LOGOUT_ERROR</b><br/>
		 * message为错误描述.</p>
		 *
		 */
		public function logout():void
		{
			//curl -u user:password -d "" http://api.t.sina.com.cn/account/end_session.xml
			addProcessor(LOGOUT_REQUEST_URL, processLogout, MicroBlogEvent.LOGOUT_RESULT, MicroBlogErrorEvent.LOGOUT_ERROR);
			var postData:URLVariables = new URLVariables();
			postData.source = "air client";
			var req:URLRequest = getMicroBlogRequest(LOGOUT_REQUEST_URL, postData, URLRequestMethod.POST);
			req.data = postData;
			executeRequest(LOGOUT_REQUEST_URL, req );
		}


		/**
		 * 用户可以通过此接口来更新头像.
		 *
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.UPDATE_PROFILE_IMAGE_RESULT</b><br/>
		 * result为一个MicroBlogUser实例.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.UPDATE_PROFILE_IMAGE_ERROR</b><br/>
		 * message为错误描述.</p>
		 *
		 * @param imgData  必须为小于700K的有效的GIF, JPG, 或 PNG 图片. 如果图片大于500像素将按比例缩放
		 *
		 */
		public function updateProfileImage(imgData:ByteArray, filename:String):void
		{
			//TO-DO: Need to be verified.
			addProcessor(UPDATE_PROFILE_IMAGE_REQUEST_URL, processUser, MicroBlogEvent.UPDATE_PROFILE_IMAGE_RESULT, MicroBlogErrorEvent.UPDATE_PROFILE_IMAGE_ERROR);
			var boundary:String=makeBoundary();
			var postData:Object = {image:imgData};
			var req:URLRequest=getMicroBlogRequest(UPDATE_PROFILE_IMAGE_REQUEST_URL, postData, URLRequestMethod.POST);
			delete postData["image"];
			req.contentType=MULTIPART_FORMDATA + boundary;
			req.data=makeMultipartPostData(boundary, "image", filename, imgData, postData);
			executeRequest(UPDATE_PROFILE_IMAGE_REQUEST_URL, req);
		}

		/**
		 * 用户可以通过此接口来更改微博信息的来源.用于无法传递ByteArray为参数的情况.
		 *
		 * <p>如果图片上传成功，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.UPDATE_DELIVERY_DEVICE_RESULT</b><br/>
		 * result为一个MicroBlogUser实例.</p>
		 *
		 * <p>如果图片上传失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.UPDATE_DELIVERY_DEVICE_ERROR</b><br/>
		 * message为错误描述.</p>
		 *
		 * @return 返回用于上传图片的URLRequest.用于在flash中用File对象上传图片，在调用File对象的upload时uploadDataFieldName必须为image
		 *
		 */
		public function getUpdateProfileImageRequest():URLRequest
		{
			addProcessor(UPDATE_PROFILE_IMAGE_REQUEST_URL, processUser, MicroBlogEvent.UPDATE_PROFILE_IMAGE_RESULT, MicroBlogErrorEvent.UPDATE_PROFILE_IMAGE_ERROR);
			var postData:URLVariables = new URLVariables();
			var req:URLRequest=getMicroBlogRequest(UPDATE_PROFILE_IMAGE_REQUEST_URL, postData, URLRequestMethod.POST);
			req.data=postData;
			return req;
		}

		/**
		 * 用户可以通过此接口来更新微博页面参数.
		 *
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.UPDATE_PROFILE_RESULT</b><br/>
		 * result为一个MicroBlogUser实例.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.UPDATE_PROFILE_ERROR</b><br/>
		 * message为错误描述.</p>
		 *
		 * @param params MicroBlogProfileUpdateParams对象，用于更新个人设置@see com.sina.microblog.data.MicroBlogProfileUpdateParams.
		 *
		 *
		 */
		public function updateProfile(params:MicroBlogProfileUpdateParams):void
		{
			//curl -u user:password -d "update_delivery_device=none" http://api.t.sina.com.cn/account/update_profile_colors.xml
			addProcessor(UPDATE_PROFILE_REQUEST_URL, processUser, MicroBlogEvent.UPDATE_PROFILE_RESULT, MicroBlogErrorEvent.UPDATE_PROFILE_ERROR);
			if (null==params || params.isEmpty)
			{
				return;
			}
			var postData:URLVariables = params.postData;
			var req:URLRequest=getMicroBlogRequest(UPDATE_PROFILE_REQUEST_URL, postData, URLRequestMethod.POST);
			req.data=postData;
			executeRequest(UPDATE_PROFILE_REQUEST_URL, req);
		}

		/**
		 * 返回用户的最近20条收藏信息，和用户收藏页面返回内容是一致的.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.LOAD_FAVORIT_LIST_RESULT</b><br/>
		 * result为一个MicroBlogStatus对象数组.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.LOAD_FAVORIT_LIST_ERROR</b><br/>
		 * message为错误描述.</p>
		 *
		 * @param page  可选参数. 返回结果的页序号。注意：有分页限制.
		 *
		 *
		 */
		public function loadFavoriteList(page:uint=0):void
		{
			addProcessor(LOAD_FAVORITE_LIST_REQUEST_URL, processStatusArray, MicroBlogEvent.LOAD_FAVORITE_LIST_RESULT, MicroBlogErrorEvent.LOAD_FAVORITE_LIST_ERROR);
	
			var url:String=LOAD_FAVORITE_LIST_REQUEST_URL;
			var params:Object=new Object();
			if ( page > 0 )
			{
				params["page"]=page.toString();
			}
			executeRequest(LOAD_FAVORITE_LIST_REQUEST_URL, getMicroBlogRequest(url, params, URLRequestMethod.GET));
		}

		/**
		 * 收藏一条微博信息.
		 *
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.ADD_TO_FAVORITES_RESULT</b><br/>
		 * result为一个MicroBlogStatus对象.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.ADD_TO_FAVORITES_ERROR</b><br/>
		 * message为错误描述.</p>
		 *
		 * @param statusID 必填参数， 要收藏的微博id.
		 *
		 */
		public function addToFavorites(statusID:uint):void
		{
			if ( statusID <= 0 )
			{
				return;
			}
			addProcessor(ADD_TO_FAVORITES_REQUEST_URL, processStatus, MicroBlogEvent.ADD_TO_FAVORITES_RESULT, MicroBlogErrorEvent.ADD_TO_FAVORITES_ERROR);

			var postData:URLVariables=new URLVariables();
			postData.id=statusID.toString();
			var req:URLRequest=getMicroBlogRequest(ADD_TO_FAVORITES_REQUEST_URL, postData, URLRequestMethod.POST);
			req.data=postData;
			executeRequest(ADD_TO_FAVORITES_REQUEST_URL, req);
		}

		/**
		 * 从收藏列表里删除一条微博信息.
		 *
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.ADD_TO_FAVORITES_RESULT</b><br/>
		 * result为一个MicroBlogStatus对象.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.ADD_TO_FAVORITES_ERROR</b><br/>
		 * message为错误描述.</p>
		 *
		 * @param statusID 必填参数， 要收藏的微博id.
		 *
		 */
		public function removeFromFavorites(statusID:uint):void
		{
			if ( statusID <= 0)
			{
				return;
			}
			addProcessor(REMOVE_FROM_FAVORITES_REQUEST_URL, processStatus, MicroBlogEvent.REMOVE_FROM_FAVORITES_RESULT, MicroBlogErrorEvent.REMOVE_FROM_FAVORITES_ERROR);
			var postData:URLVariables = new URLVariables();
			var req:URLRequest=getMicroBlogRequest(REMOVE_FROM_FAVORITES_REQUEST_URL.replace("$id", statusID), postData, URLRequestMethod.POST);
			req.data = postData;
			executeRequest(REMOVE_FROM_FAVORITES_REQUEST_URL, req);
		}

//		/**
//		 * 允许/禁止通知更新给指定用户.
//		 *
//		 * <b>有请求数限制</b>
//		 * 
//		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
//		 * type为<b>MicroBlogEvent.FOLLOW_NOTIFICATION_RESULT</b><br/>
//		 * result为一个MicroBlogUser对象.</p>
//		 *
//		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
//		 * type为<b>MicroErrorEvent.FOLLOW_NOTIFICATION_ERROR</b><br/>
//		 * message为错误描述.</p>
//		 *
//		 * @param isEnable 必选参数
//		 * @param user 指定的用户ID或用户帐号.
//		 * @param page  指定的用户UID.
//		 * @param screenName 指定的用户帐号
//		 *
//		 * 以上三个可选参数必须设置一个
//		 *
//		 */
//		public function enableNotification(isEnable:Boolean, user:String=null, userID:uint=0, screenName:String=null):void
//		{
//			addProcessor(ENABLE_NOTIFICATION_REQUEST_URL, processUser, MicroBlogEvent.ENABLE_NOTIFICATION_RESULT, MicroBlogErrorEvent.ENABLE_NOTIFICATION_ERROR);
//			var hasParam:Boolean=false;
//			if (user && user.length > 0)
//			{
//				user="/" + user;
//				hasParam=true;
//			}
//			else
//			{
//				user="";
//			}
//			var url:String;
//			if (isEnable)
//			{
//				url=ENABLE_NOTIFICATION_REQUEST_URL.replace("$enabled", "follow");
//			}
//			else
//			{
//				url=ENABLE_NOTIFICATION_REQUEST_URL.replace("$enabled", "leave");
//			}
//			url=url.replace("$user", user);
//			var postData:URLVariables=new URLVariables();
//			if (userID > 0)
//			{
//				postData.user_id=userID;
//				hasParam=true;
//			}
//			if (screenName && screenName.length > 0)
//			{
//				postData.screen_name=StringEncoders.urlEncodeUtf8String(screenName);
//				hasParam=true;
//			}
//			if (!hasParam)
//			{
//				return;
//			}
//			var req:URLRequest=getMicroBlogRequest(url, postData, URLRequestMethod.POST);
//			req.data=postData;
//			executeRequest(ENABLE_NOTIFICATION_REQUEST_URL, req);
//		}
//		
		/**
		 * 返回省份，城市的名字对应id的列表，为xml格式.
		 *
		 * <b>有请求数限制</b>
		 * 
		 * <p>如果该函数被成功执行，将会抛出MicroBlogEvent事件，该事件<br/>
		 * type为<b>MicroBlogEvent.LOAD_PROVINCE_CITY_ID_LIST_RESULT</b><br/>
		 * result为一个XML对象.</p>
		 *
		 * <p>如果该函数调用失败，将会抛出MicroBlogErrorEvent事件，该事件<br/>
		 * type为<b>MicroErrorEvent.LOAD_PROVINCE_CITY_ID_LIST_ERROR</b><br/>
		 * message为错误描述.</p>
		 *
		 * <p>返回的xml数据格式请参看新浪微博开放平台 http://open.t.sina.com.cn
		 * </p>
		 * 
		 * <p>要想获取省份id为11，城市id为1的地址信息可以参考以下方法<br/>
		 * <pre>
		 * var prov:XML = provinces.province.(&#64;id == "11")[0];
		 * province = prov.&#64;name;
		 * city = prov.city.(&#64;id == "1")[0].&#64;name;
		 * </pre>
		 * 通过名字得到id可以参考如下方法<br/>
		 * <pre>
		 * var prov:XML = provinces.province.(&#64;name == "北京")[0];
		 * provinceID = prov.&#64;id;
		 * cityID = prov.city.(&#64;name == "东城区")[0].&#64;id;
		 * </pre>
		 * </p>
		 */
		public function loadProvinceCityIDList():void
		{
			addProcessor(LOAD_PROVINCE_CITY_ID_LIST, processProvincesXML, MicroBlogEvent.LOAD_PROVINCE_CITY_ID_LIST_RESULT, MicroBlogErrorEvent.LOAD_PROVINCE_CITY_ID_LIST_ERROR);
			executeRequest(LOAD_PROVINCE_CITY_ID_LIST, getMicroBlogRequest(LOAD_PROVINCE_CITY_ID_LIST, null) );
		}
		//Event handler

		private function addProcessor(name:String, dataProcess:Function, resultEventType:String, errorEventType:String):void
		{
			if (null == serviceLoader[name])
			{
				var loader:URLLoader=new URLLoader();
				loader.addEventListener(Event.COMPLETE, loader_onComplete);
				loader.addEventListener(IOErrorEvent.IO_ERROR, loader_onError);
				loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, loader_onSecurityError);
				serviceLoader[name]=loader;
				loaderMap[loader]={dataFunc: dataProcess, resultEvent: resultEventType, errorEvent: errorEventType};
			}
		}
		
		private function executeRequest(name:String, req:URLRequest):void
		{
			var urlLoader:URLLoader = serviceLoader[name] as URLLoader;
			lastLoader = urlLoader;
			lastRequest = req;
			urlLoader.load(req);
		}

		private function loader_onComplete(event:Event):void
		{
			var loader:URLLoader=event.target as URLLoader;
			var processor:Object=loaderMap[loader];
			var dataStr:String = loader.data as String;
			if ( dataStr.length  <= 0 )
			{
				var ioError:MicroBlogErrorEvent = new MicroBlogErrorEvent(MicroBlogErrorEvent.NET_WORK_ERROR);
				ioError.message = "The network error";
				dispatchEvent(ioError);
				return;
			}
			var result:XML=new XML(loader.data);
			
			if (result.child("error").length() > 0)
			{
				var error:MicroBlogErrorEvent=new MicroBlogErrorEvent(processor.errorEvent);
				error.message="Error " + result.error_code + " : " + result.error;
				dispatchEvent(error);
			}
			else
			{
				var e:MicroBlogEvent=new MicroBlogEvent(processor.resultEvent);
				e.result=processor.dataFunc(result);
				e.nextCursor=Number(result.next_cursor);
				e.previousCursor=Number(result.previous_cursor);
				dispatchEvent(e);
			}
			//trace(loader.data);
		}

		private function loader_onError(event:IOErrorEvent):void
		{
			var loader:URLLoader=event.target as URLLoader;
			var processor:Object=loaderMap[loader];
			var error:MicroBlogErrorEvent=new MicroBlogErrorEvent(processor.errorEvent);
			error.message=event.text;
			dispatchEvent(error);
		}

		private function loader_onSecurityError(event:SecurityErrorEvent):void
		{
			dispatchEvent(event);
		}

		private function getMicroBlogRequest(url:String, params:Object, requestMethod:String="GET"):URLRequest
		{
			var req:URLRequest;
			
			if ( null == params )
			{
				params = new Object();
			}
			params["source"] = source;
			if ( accessTokenKey.length > 0)
			{
				req=signRequest(requestMethod, url, params, false);
			}
			else
			{
				if (requestMethod == URLRequestMethod.GET)
				{
					url+=makeGETParamString(params);
				}
				req=new URLRequest(url);
				if ( authHeader )
				{
					req.requestHeaders.push(authHeader);
				}
			}
			req.method=requestMethod;
			return req;
		}

		private function processStatusArray(statuses:XML):Array
		{
			var microBlogStatus:MicroBlogStatus;
			var statusArray:Array = new Array();
			for each (var status:XML in statuses.status)
			{
				microBlogStatus=new MicroBlogStatus(status);
				statusArray.push(microBlogStatus);
			}
			return statusArray;
		}

		private function processStatus(status:XML):MicroBlogStatus
		{
			return new MicroBlogStatus(status);
		}

		private function processCommentArray(comments:XML):Array
		{
			var microBlogComment:MicroBlogComment;
			var commentArray:Array=[];
			for each (var comment:XML in comments.comment)
			{
				microBlogComment=new MicroBlogComment(comment);
				commentArray.push(microBlogComment);
			}
			return commentArray;
		}

		private function processComment(comment:XML):MicroBlogComment
		{
			return new MicroBlogComment(comment);
		}

		private function processCounts(counts:XML):Array
		{
			var countArray:Array=[];
			var count:MicroBlogCount;
			for each (var countValue:XML in counts.children())
			{
				count=new MicroBlogCount(countValue);
				countArray.push(count);
			}
			return countArray;
		}

		private function processUser(user:XML):MicroBlogUser
		{
			return new MicroBlogUser(user);
		}

		private function processUserArray(users:XML):Array
		{
			var userArray:Array=[];
			var mbUser:MicroBlogUser;
			for each (var userValue:XML in users.user)
			{
				mbUser=new MicroBlogUser(userValue);
				userArray.push(mbUser);
			}
			return userArray;
		}

		private function processDirectMessageArray(messages:XML):Array
		{
			var messageArray:Array=[];
			var mbMessage:MicroBlogDirectMessage;
			for each (var messageValue:XML in messages.direct_message)
			{
				mbMessage=new MicroBlogDirectMessage(messageValue);
				messageArray.push(mbMessage);
			}
			return messageArray;
		}

		private function processDirectMessage(message:XML):MicroBlogDirectMessage
		{
			return new MicroBlogDirectMessage(message);
		}

//		private function processBoolean(message:XML):Boolean
//		{
//			return message.toString() == "true";
//		}

		private function processRelationship(message:XML):MicroBlogUsersRelationship
		{
			return new MicroBlogUsersRelationship(message);
		}

		private function processIDSArray(message:XML):Array
		{
			var ar:Array=[];
			for each (var id:XML in message.ids[0].children())
			{
				ar.push(uint(id.toString()));
			}
			return ar;
		}
		private function processRateLimit(message:XML):MicroBlogRateLimit
		{
			return new MicroBlogRateLimit(message);
		}
		private function processLogout(user:XML):MicroBlogUser
		{
			_accessTokenKey = "";
			_accessTokenSecret = "";
			authHeader = null;
			return new MicroBlogUser(user);
		}
		private function processProvincesXML(result:XML):XML
		{
			return result;
		}
		private function makeGETParamString(parameters:Object):String
		{
			var paramStr:String=makeParamsToUrlString(parameters);
			if (paramStr.length > 0)
			{
				paramStr="?" + paramStr;
			}
			return paramStr;
		}

		private function makeQueryCombinatory(params:Object, sinceID:uint, maxID:uint, count:uint, page:uint):void
		{

			if (sinceID > 0)
			{
				params[SINCE_ID]=sinceID;

			}
			if (maxID > 0)
			{
				params[MAX_ID]=maxID;

			}
			if (count > 0)
			{
				params[COUNT]=count;

			}
			if (page > 0)
			{
				params[PAGE]=page;
			}

		}

		private function makeUserParams(params:Object, userID:uint, screenName:String, cursor:Number):void
		{

			if (userID > 0)
			{
				params[USER_ID]=userID;

			}
			if (screenName)
			{
				params[SCREEN_NAME]=screenName;

			}
			if (cursor >= 0)
			{
				params[CURSOR]=cursor;

			}

		}

		private function makeBoundary():String
		{
			var boundary:String="";

			for (var i:int=0; i < 13; i++)
			{
				boundary+=String.fromCharCode(int(97 + Math.random() * 25));
			}
			boundary="---------------------------" + boundary;

			return boundary;
		}

		private function encodeMsg(status:String):String
		{
			return StringEncoders.urlEncodeSpecial(status);
		}

		private function makeMultipartPostData(boundary:String, imgFieldName:String, filename:String, imgData:ByteArray, params:Object):Object
		{
			var req:URLRequest=new URLRequest();
			var postData:ByteArray=new ByteArray();
			postData.endian=Endian.BIG_ENDIAN;
			var value:String;

			//add params to the post data.
			if (params)
			{
				for (var name:String in params)
				{
					boundaryPostData(postData, boundary);
					addLineBreak(postData);
					//writeStringToByteArray(postData, CONTENT_DISPOSITION_BASIC.replace("$name", name));
					postData.writeUTFBytes(CONTENT_DISPOSITION_BASIC.replace("$name", name));
					addLineBreak(postData);
					addLineBreak(postData);
					postData.writeUTFBytes(params[name]);
					addLineBreak(postData);
				}
			}
			//add image;
//			--BbC04y
//			Content-Disposition: file; filename="file2.jpg"
//			Content-Type: image/jpeg
//			Content-Transfer-Encoding: binary
//			
//			...contents of file2.jpg...
//			--BbC04y--

			boundaryPostData(postData, boundary);
			addLineBreak(postData);
			//writeStringToByteArray(postData, CONTENT_DISPOSITION_BASIC.replace("$name", "files") + '; filename="'+filename + '"');
			postData.writeUTFBytes(CONTENT_DISPOSITION_BASIC.replace("$name", imgFieldName) + '; filename="' + filename + '"');
			addLineBreak(postData);
			//writeStringToByteArray(postData, CONTENT_TYPE_JPEG);
			postData.writeUTFBytes(CONTENT_TYPE_JPEG);
			addLineBreak(postData);
			//writeStringToByteArray(postData,CONTENT_TRANSFER_ENCODING);
			//postData.writeUTFBytes(CONTENT_TRANSFER_ENCODING);
			//addLineBreak(postData);
			addLineBreak(postData);
			postData.writeBytes(imgData, 0, imgData.length);
			addLineBreak(postData);

			boundaryPostData(postData, boundary);
			addDoubleDash(postData);

			trace(postData.toString());
			postData.position=0;
			return postData;
		}

		private function boundaryPostData(data:ByteArray, boundary:String):void
		{
			var len:int=boundary.length;
			addDoubleDash(data);
			for (var i:int=0; i < len; ++i)
			{
				data.writeByte(boundary.charCodeAt(i));
			}
		}

		private function addDoubleDash(data:ByteArray):void
		{
			data.writeShort(0x2d2d);
		}

		private function addLineBreak(data:ByteArray):void
		{
			data.writeShort(0x0d0a);
		}


		private function signRequest(requestMethod:String, url:String, requestParams:Object, useHead:Boolean=false):URLRequest
		{
			var method:String=requestMethod.toUpperCase();
			var oauthParams:Object=getOAuthParams();
			var params:Object=new Object;
			for (var key:String in oauthParams)
			{
				params[key]=oauthParams[key];
			}
			for (var key1:String in requestParams)
			{
				params[key1]=requestParams[key1];
			}

			var req:URLRequest=new URLRequest();
			req.method=method;
			req.url=url;
			var paramsStr:String=makeSignableParamStr(params);
			var msgStr:String=StringEncoders.urlEncodeUtf8String(requestMethod.toUpperCase()) + "&";
			msgStr+=StringEncoders.urlEncodeUtf8String(url);
			msgStr+="&";
			msgStr+=StringEncoders.urlEncodeUtf8String(paramsStr);
			
			var secrectStr:String=_consumerSecret + "&";
			if (_accessTokenSecret.length > 0 && _accessTokenKey.length > 0)
			{
				secrectStr+=_accessTokenSecret;
			}
			var sig:String=Base64.encode(HMAC.hash(secrectStr, msgStr, SHA1));
			// The matchers are specified in OAuth only.
			sig = sig.replace(/\+/g, "%2B");
			
			oauthParams["oauth_signature"]=sig;
			trace("BaseString:::::", msgStr);
			trace("signature::::", sig);
			
			if (method == URLRequestMethod.GET)
			{
				if (useHead)
				{
					req.url+=("?" + makeSignableParamStr(requestParams));
					req.requestHeaders.push(makeOauthHeaderFromArray(oauthParams));
				}
				else
				{
					req.url+=("?" + paramsStr + '&oauth_signature=' + sig);
				}
			}
			else if (requestMethod == URLRequestMethod.POST)
			{
				req.requestHeaders.push(makeOauthHeaderFromArray(oauthParams));
			}
			return req;
		}

		private function makeSignableParamStr(params:Object):String
		{
			var retParams:Array=[];

			for (var param:String in params)
			{
				if (param != "oauth_signature")
				{
					retParams.push(param + "=" + StringEncoders.urlEncodeUtf8String(params[param].toString()));
					//retParams.push(param + "=" +params[param].toString());
				}	
				
			}

			retParams.sort();

			return retParams.join("&");
		}

		private function makeParamsToUrlString(params:Object):String
		{
			var retParams:Array=[];

			for (var param:String in params)
			{
				retParams.push(param + "=" + params[param].toString());
			}

			retParams.sort();

			return retParams.join("&");
		}

		private function makeOauthHeaderFromArray(params:Object):URLRequestHeader
		{
			var oauthHeaderValue:String='OAuth realm="' + API_BASE_URL + '",';
			var parseParams:Array=[];
			for (var key:String in params)
			{
				parseParams.push(key + '="' + params[key] + '"');
			}
			oauthHeaderValue+=parseParams.join(",");

			var reqHeader:URLRequestHeader=new URLRequestHeader("Authorization", oauthHeaderValue);
			return reqHeader;
		}

		private function getOAuthParams():Object
		{
			var params:Object=new Object;
			var now:Date=new Date();

			params["oauth_consumer_key"]=_consumerKey;
			if (_accessTokenKey.length > 0)
			{
				params["oauth_token"]=_accessTokenKey;
			}
			if ( _pin && _pin.length > 0 )
			{
				params["oauth_verifier"] = _pin;
			}
			params["oauth_signature_method"]="HMAC-SHA1";
			params["oauth_timestamp"]=now.time.toString().substr(0, 10);
			params["oauth_nonce"]=GUID.createGUID();
			params["oauth_version"]="1.0";
			params["oauth_callback"]="oob";
			return params;
		}

		private function oauthLoader_onComplete(event:Event):void
		{
			trace(oauthLoader.data);
			var needRequestAuthorize:Boolean=_accessTokenKey.length == 0;
			var result:String=oauthLoader.data as String;

			if (result.length > 0)
			{
				var urlVar:URLVariables=new URLVariables(oauthLoader.data);
				_accessTokenKey=urlVar.oauth_token;
				_accessTokenSecret=urlVar.oauth_token_secret;
				if (needRequestAuthorize)
				{
					requestAuthorize();
					needRequestAuthorize=false;
				}
				else
				{
					var e:MicroBlogEvent=new MicroBlogEvent(MicroBlogEvent.OAUTH_CERTIFICATE_RESULT);
					e.result={oauthTokenKey: _accessTokenKey, oauthTokenSecrect: _accessTokenSecret};
					dispatchEvent(e);
					verifyCredentials();
				}
			}

		}

		private function oauthLoader_onError(event:IOErrorEvent):void
		{
			//var urlData:URLVariables = new URLVariables(oauthLoader.data);
			var e:MicroBlogErrorEvent = new MicroBlogErrorEvent(MicroBlogErrorEvent.OAUTH_CERTIFICATE_ERROR);
			e.message = oauthLoader.data;
			dispatchEvent(e);
		}

		private function oauthLoader_onSecurityError(event:SecurityErrorEvent):void
		{
			dispatchEvent(event);
		}

		private function requestAuthorize():void
		{
			var url:String=OAUTH_AUTHORIZE_REQUEST_URL;
			url+="?oauth_token=" + StringEncoders.urlEncodeUtf8String(_accessTokenKey);
			url+="&oauth_callback=oob";
			navigateToURL(new URLRequest(url));
		}
	}
}